export const forEach = (arr, fn) => {
  if (!arr.length || !fn) return
  let i = -1
  let len = arr.length
  while (++i < len) {
    let item = arr[i]
    fn(item, i, arr)
  }
}

/**
 * @param {Array} arr1
 * @param {Array} arr2
 * @description 得到两个数组的交集, 两个数组的元素为数值或字符串
 */
export const getIntersection = (arr1, arr2) => {
  let len = Math.min(arr1.length, arr2.length)
  let i = -1
  let res = []
  while (++i < len) {
    const item = arr2[i]
    if (arr1.indexOf(item) > -1) res.push(item)
  }
  return res
}

/**
 * @param {Array} arr1
 * @param {Array} arr2
 * @description 得到两个数组的并集, 两个数组的元素为数值或字符串
 */
export const getUnion = (arr1, arr2) => {
  return Array.from(new Set([...arr1, ...arr2]))
}

/**
 * @param {Array} arr1
 * @param {Array} arr2
 * @description 得到两个数组的差集, 两个数组的元素为数值或字符串
 */
export const getDiff = (arr1, arr2) => {
  return Array.from(new Set(arr1.filter(item => arr2.indexOf(item) === -1)))
}

/**
 * @param {Array} target 目标数组
 * @param {Array} arr 需要查询的数组
 * @description 判断要查询的数组是否至少有一个元素包含在目标数组中
 */
export const hasOneOf = (targetarr, arr) => {
  return targetarr.some(_ => arr.indexOf(_) > -1)
}

/**
 * @param {String|Number} value 要验证的字符串或数值
 * @param {*} validList 用来验证的列表
 */
export function oneOf (value, validList) {
  for (let i = 0; i < validList.length; i++) {
    if (value === validList[i]) {
      return true
    }
  }
  return false
}

/**
 * @param {Number} timeStamp 判断时间戳格式是否是毫秒
 * @returns {Boolean}
 */
const isMillisecond = timeStamp => {
  const timeStr = String(timeStamp)
  return timeStr.length > 10
}

/**
 * @param {Number} timeStamp 传入的时间戳
 * @param {Number} currentTime 当前时间时间戳
 * @returns {Boolean} 传入的时间戳是否早于当前时间戳
 */
const isEarly = (timeStamp, currentTime) => {
  return timeStamp < currentTime
}

/**
 * @param {Number} num 数值
 * @returns {String} 处理后的字符串
 * @description 如果传入的数值小于10，即位数只有1位，则在前面补充0
 */
const getHandledValue = num => {
  return num < 10 ? '0' + num : num
}

/**
 * @param {Number} timeStamp 传入的时间戳
 * @param {Number} startType 要返回的时间字符串的格式类型，传入'year'则返回年开头的完整时间
 */
const getDate = (timeStamp, startType) => {
  const d = new Date(timeStamp * 1000)
  const year = d.getFullYear()
  const month = getHandledValue(d.getMonth() + 1)
  const date = getHandledValue(d.getDate())
  const hours = getHandledValue(d.getHours())
  const minutes = getHandledValue(d.getMinutes())
  const second = getHandledValue(d.getSeconds())
  let resStr = ''
  if (startType === 'year') resStr = year + '-' + month + '-' + date + ' ' + hours + ':' + minutes + ':' + second
  else resStr = month + '-' + date + ' ' + hours + ':' + minutes
  return resStr
}

/**
 * @param {String|Number} timeStamp 时间戳
 * @returns {String} 相对时间字符串
 */
export const getRelativeTime = timeStamp => {
  // 判断当前传入的时间戳是秒格式还是毫秒
  const IS_MILLISECOND = isMillisecond(timeStamp)
  // 如果是毫秒格式则转为秒格式
  if (IS_MILLISECOND) Math.floor(timeStamp /= 1000)
  // 传入的时间戳可以是数值或字符串类型，这里统一转为数值类型
  timeStamp = Number(timeStamp)
  // 获取当前时间时间戳
  const currentTime = Math.floor(Date.parse(new Date()) / 1000)
  // 判断传入时间戳是否早于当前时间戳
  const IS_EARLY = isEarly(timeStamp, currentTime)
  // 获取两个时间戳差值
  let diff = currentTime - timeStamp
  // 如果IS_EARLY为false则差值取反
  if (!IS_EARLY) diff = -diff
  let resStr = ''
  const dirStr = IS_EARLY ? '前' : '后'
  // 少于等于59秒
  if (diff <= 59) resStr = diff + '秒' + dirStr
  // 多于59秒，少于等于59分钟59秒
  else if (diff > 59 && diff <= 3599) resStr = Math.floor(diff / 60) + '分钟' + dirStr
  // 多于59分钟59秒，少于等于23小时59分钟59秒
  else if (diff > 3599 && diff <= 86399) resStr = Math.floor(diff / 3600) + '小时' + dirStr
  // 多于23小时59分钟59秒，少于等于29天59分钟59秒
  else if (diff > 86399 && diff <= 2623859) resStr = Math.floor(diff / 86400) + '天' + dirStr
  // 多于29天59分钟59秒，少于364天23小时59分钟59秒，且传入的时间戳早于当前
  else if (diff > 2623859 && diff <= 31567859 && IS_EARLY) resStr = getDate(timeStamp)
  else resStr = getDate(timeStamp, 'year')
  return resStr
}

/**
 * @returns {String} 当前浏览器名称
 */
export const getExplorer = () => {
  const ua = window.navigator.userAgent
  const isExplorer = (exp) => {
    return ua.indexOf(exp) > -1
  }
  if (isExplorer('MSIE')) return 'IE'
  else if (isExplorer('Firefox')) return 'Firefox'
  else if (isExplorer('Chrome')) return 'Chrome'
  else if (isExplorer('Opera')) return 'Opera'
  else if (isExplorer('Safari')) return 'Safari'
}

/**
 * @description 绑定事件 on(element, event, handler)
 */
export const on = (function () {
  if (document.addEventListener) {
    return function (element, event, handler) {
      if (element && event && handler) {
        element.addEventListener(event, handler, false)
      }
    }
  } else {
    return function (element, event, handler) {
      if (element && event && handler) {
        element.attachEvent('on' + event, handler)
      }
    }
  }
})()

/**
 * @description 解绑事件 off(element, event, handler)
 */
export const off = (function () {
  if (document.removeEventListener) {
    return function (element, event, handler) {
      if (element && event) {
        element.removeEventListener(event, handler, false)
      }
    }
  } else {
    return function (element, event, handler) {
      if (element && event) {
        element.detachEvent('on' + event, handler)
      }
    }
  }
})()

/**
 * 判断一个对象是否存在key，如果传入第二个参数key，则是判断这个obj对象是否存在key这个属性
 * 如果没有传入key这个参数，则判断obj对象是否有键值对
 */
export const hasKey = (obj, key) => {
  if (key) return key in obj
  else {
    let keysArr = Object.keys(obj)
    return keysArr.length
  }
}

/**
 * @param {*} obj1 对象
 * @param {*} obj2 对象
 * @description 判断两个对象是否相等，这两个对象的值只能是数字或字符串
 */
export const objEqual = (obj1, obj2) => {
  const keysArr1 = Object.keys(obj1)
  const keysArr2 = Object.keys(obj2)
  if (keysArr1.length !== keysArr2.length) return false
  else if (keysArr1.length === 0 && keysArr2.length === 0) return true
  /* eslint-disable-next-line */
  else return !keysArr1.some(key => obj1[key] != obj2[key])
}

/**
 * @returns {Number} 当前学年
 * @description 计算当前学年
 */
export const currAcademicYear = () => {
  const currDate = new Date()
  const currYear = currDate.getFullYear()
  const currMonth = currDate.getMonth() + 1
  return currMonth > 8 ? currYear : currYear - 1
}

/**
 * @returns {String} 当前学期
 * @description 计算当前学期
 */
export const currTerm = () => {
  return new Date().getMonth() + 1 <= 2 ? '第一学期' : '第二学期'
}

/**
 * @returns {String} 当前天是星期几
 * @description 计算当前天是星期几
 */
export const currWeekDay = () => {
  const weekDays = ['Sunday', 'Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday', 'Saturday']
  return weekDays[new Date().getDay()]
}

/**
 * @param {String} startTime 起始时间
 * @param {String} endTime 终止时间
 * @returns {Number} 起始时间与终止时间之间相差的天数（包含终止时间当天）
 * @description 计算起始时间与终止时间之间相差的天数（包含终止时间当天）
*/
export const diffDays = (startTime, endTime) => {
  console.log(startTime)
  console.log(endTime)
  // 将日期格式yyyy-mm-dd转换成yyyy/mm/dd，
  // 基于'/'格式的日期字符串，才是被各大浏览器所广泛支持的
  startTime = startTime.replace(/-/g, '/')
  endTime = endTime.replace(/-/g, '/')
  // Date.parse()静态方法的返回值为1970年1月1日午夜到当前字符串时间的毫秒数
  // 如果传入的日期只包含年月日不包含时分秒，如yyyy/mm/dd，则默认取的毫秒数为yyyy/mm/dd 00:00:00，
  // 截止到yyyy年mm月dd日的0时0分0秒，因此计算时如果要包含终止时间的当前天，就要加上一天的毫秒数
  let diffMilliSecond = Date.parse(endTime) - Date.parse(startTime) + 24 * 60 * 60 * 1000
  // 两者相差的天数
  return diffMilliSecond / (24 * 60 * 60 * 1000)
}

/**
 * @description 生成guid
 */
export const generateGuid = () => {
  return 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, function (c) {
    let r = Math.random() * 16 | 0
    let v = c === 'x' ? r : (r & 0x3 | 0x8)
    return v.toString(16)
  })
}
/**
 * @description 获取当前元素的最终css样式信息
 * @param element 当前元素
 * @param attr 属性名称
 * @see https://blog.csdn.net/u014205965/article/details/45772539
 * @returns {*}
 */
export const getFinalStyle = (element, attr) => {
  return getComputedStyle ? window.getComputedStyle(element)[attr] : element.currentStyle[attr]
}

/**
 * @description 当前登录用户是否拥有某些权限
 * @param {Array} userAccess 当前用户权限
 * @param {Array} needAccess 需要的权限
 * @returns {Boolean} 有 = true,  无 = false
 */
export const isIncludesAccess = (userAccess, needAccess) => {
  return userAccess.some(item => { return needAccess.includes(item) })
}

/**
 * @Description: 表格右键拖动
 * @Params: {Object} element: 表格主体元素（含有滚动条）
 * @Return: {null}
 * @Author: Jackie
 * @Date: 2019/2/11 21:02
 */
export const activeTableMove = (element) => {
  let move = false
  let mouseMoveHandle = null
  let contextmenuHandle = null
  // 绑定mousedown事件
  on(document, 'mousedown', event => {
    let ev = document.all ? window.event : event
    // ev.which鼠标右键的值为3，ev.button鼠标右键的值为2
    let evCode = ev.which || ev.button + 1
    // 鼠标右键
    if (evCode === 3) {
      // 记录鼠标点击的x坐标和y坐标
      let startX = ev.pageX
      let startY = ev.pageY
      move = false
      // 绑定mousemove事件
      on(element, 'mousemove', mouseMoveHandle = (() => {
        return event => {
          let ev = document.all ? window.event : event
          ev.preventDefault()
          // 计算鼠标移动的x轴、y轴偏移量，赋值列表的横向、竖向滚动条
          element.scrollLeft += startX - ev.pageX
          element.scrollTop += startY - ev.pageY
          /* 偏移量绝对值大于3即视为有滑动 */
          if (Math.abs(startX - ev.pageX) >= 2 || Math.abs(startY - ev.pageY) >= 2) {
            move = true
            element.style.cursor = 'move'
            // to do what you want
          }
          // 记录最新的起始坐标
          startX = ev.pageX
          startY = ev.pageY
        }
      })(move)) // 给闭包函数传递外部的局部变量，很重要！很重要！很重要！
    }
  })
  // 松开鼠标（先绑定mouseup事件），取消已绑定mousemove事件
  on(document, 'mouseup', event => {
    let ev = document.all ? window.event : event
    let evCode = ev.which || ev.button + 1
    if (evCode === 3) {
      off(element, 'mousemove', mouseMoveHandle)
      element.style.cursor = 'default'
      // 鼠标右键是否弹出菜单
      off(document, 'contextmenu', contextmenuHandle)
      on(document, 'contextmenu', contextmenuHandle = (() => {
        return event => {
          if (move) {
            event.preventDefault ? event.preventDefault() : event.returnValue = false
          }
        }
      })(move))
    }
  })
}

/**
 * @param {String} str 需要处理的字符串
 * @description 去掉字符串两端的多余的空格
 */
export const trim = (str) => {
  return str.replace(/^\s+|\s+$/gm, '')
}
